﻿using System;
using System.Collections.Generic;
using System.Text;

using RaisingStudio.Data.Common;
using RaisingStudio.Data.Expressions;
using RaisingStudio.Data.Common.Factories;
using RaisingStudio.Data.Providers.Adapters;
using RaisingStudio.Data.Providers.Adapters.Generic;

namespace RaisingStudio.Data.Providers
{
    public partial class DataProvider : RaisingStudio.Data.Common.IGenericDataProvider
    {
        #region Common Methods
        /// <summary>
        /// Gets datatable DataAdapter.
        /// </summary>
        /// <typeparam name="T">datatable Type.</typeparam>
        /// <returns>datatable DataAdapter.</returns>
        public virtual DataTableAdapter<T> GetDataTableAdapter<T>() where T : System.Data.DataTable
        {
            return new DataTableAdapter<T>(GetDataTableAdapter(typeof(T)));
        }

        /// <summary>
        /// Gets data object DataAdapter.
        /// </summary>
        /// <typeparam name="T">data Type of data object.</typeparam>
        /// <returns>data object DataAdapter.</returns>
        public virtual DataObjectAdapter<T> GetDataObjectAdapter<T>()
        {
            return new DataObjectAdapter<T>(GetDataObjectAdapter(typeof(T)));
        }

        /// <summary>
        /// Gets DataItem DataAdapter.
        /// </summary>
        /// <typeparam name="T">DataItem Type.</typeparam>
        /// <returns>DataItem DataAdapter.</returns>
        public virtual DataItemAdapter<T> GetDataItemAdapter<T>() where T : RaisingStudio.Data.DataItem
        {
            return new DataItemAdapter<T>(GetDataItemAdapter(typeof(T)));
        }

        /// <summary>
        /// Gets dataset DataAdapter.
        /// </summary>
        /// <typeparam name="T">dataset Type.</typeparam>
        /// <returns>dataset DataAdapter.</returns>
        public virtual DataSetAdapter<T> GetDataSetAdapter<T>() where T : System.Data.DataSet
        {
            return new DataSetAdapter<T>(GetDataSetAdapter(typeof(T)));
        }
        #endregion
        
        #region DataTable Functions 
        public T ExecuteDataTable<T>(CommonCommand selectCommand) where T : System.Data.DataTable
        {
            return (T)ExecuteDataTable(typeof(T), selectCommand);
        }

        public T ExecuteDataTable<T>(CommonCommand selectCommand, string transactionID) where T : System.Data.DataTable
        {
            return (T)ExecuteDataTable(typeof(T), selectCommand, transactionID);
        }

        public T GetDataTable<T>(string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), transactionID);
        }

        public T GetDataTable<T>(object[] primaryKeys, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), primaryKeys, transactionID);
        }

        public T GetDataTable<T>(object[] primaryKeys, string[] columnNames, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), primaryKeys, columnNames, transactionID);
        }

        public T GetDataTable<T>(string[] columnNames, int startRecord, int maxRecords) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnNames, startRecord, maxRecords);
        }

        public T GetDataTable<T>(int startRecord, int maxRecords) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), startRecord, maxRecords);
        }

        public T GetDataTable<T>(string[] columnNames, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnNames, transactionID);
        }

        public T GetDataTable<T>(CommonCommand conditionCommand, int startRecord, int maxRecords) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), conditionCommand, startRecord, maxRecords);
        }

        public T GetDataTable<T>() where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T));
        }

        public T GetDataTable<T>(CommonCommand conditionCommand, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), conditionCommand, transactionID);
        }

        public T GetDataTable<T>(string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnNames, conditionCommand, startRecord, maxRecords);
        }

        public T GetDataTable<T>(string[] columnNames, CommonCommand conditionCommand, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnNames, conditionCommand, transactionID);
        }

        public T GetDataTable<T>(CommonCommand conditionCommand) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), conditionCommand);
        }

        public T GetDataTable<T>(string[] columnNames) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnNames);
        }

        public T GetDataTable<T>(string[] columnNames, CommonCommand conditionCommand) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnNames, conditionCommand);
        }

        public T GetDataTable<T>(object[] primaryKeys, string[] columnNames) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), primaryKeys, columnNames);
        }

        public T GetDataTable<T>(object[] primaryKeys) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), primaryKeys);
        }

        public T GetDataTable<T>(string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public T GetDataTable<T>(CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), conditionCommand, startRecord, maxRecords, transactionID);
        }

        public T GetDataTable<T>(string[] columnNames, int startRecord, int maxRecords, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnNames, startRecord, maxRecords, transactionID);
        }

        public T GetDataTable<T>(int startRecord, int maxRecords, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), startRecord, maxRecords, transactionID);
        }

        public T GetViewData<T>(string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public T GetViewData<T>(CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), conditionCommand, startRecord, maxRecords, transactionID);
        }

        public T GetViewData<T>(CommonCommand conditionCommand, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), conditionCommand, transactionID);
        }

        public T GetViewData<T>(string[] columnNames, CommonCommand conditionCommand, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), columnNames, conditionCommand, transactionID);
        }

        public T GetViewData<T>(string[] columnNames, CommonCommand conditionCommand) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), columnNames, conditionCommand);
        }

        public T GetViewData<T>(CommonCommand conditionCommand) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), conditionCommand);
        }

        public T GetViewData<T>(CommonCommand conditionCommand, int startRecord, int maxRecords) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), conditionCommand, startRecord, maxRecords);
        }

        public T GetViewData<T>(string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), columnNames, conditionCommand, startRecord, maxRecords);
        }


        public int Delete<T>(string transactionID)
        {
            return Delete(typeof(T), transactionID);
        }

        public int Delete<T>()
        {
            return Delete(typeof(T));
        }

        public int Delete<T>(string[] columnNames, object[] originalValues)
        {
            return Delete(typeof(T), columnNames, originalValues);
        }

        public int Delete<T>(object[] primaryKeys)
        {
            return Delete(typeof(T), primaryKeys);
        }

        public int Delete<T>(CommonCommand conditionCommand)
        {
            return Delete(typeof(T), conditionCommand);
        }

        public int Delete<T>(System.Collections.Generic.Dictionary<string, object> originalValues)
        {
            return Delete(typeof(T), originalValues);
        }

        public int Delete<T>(string[] columnNames, object[] originalValues, string transactionID)
        {
            return Delete(typeof(T), columnNames, originalValues, transactionID);
        }

        public int Delete<T>(object[] primaryKeys, string transactionID)
        {
            return Delete(typeof(T), primaryKeys, transactionID);
        }

        public int Delete<T>(CommonCommand conditionCommand, string transactionID)
        {
            return Delete(typeof(T), conditionCommand, transactionID);
        }

        public int Delete<T>(System.Collections.Generic.Dictionary<string, object> originalValues, string transactionID)
        {
            return Delete(typeof(T), originalValues, transactionID);
        }

        public int ExecuteDataTableNonQueryCommand<T>(CommonCommand commonCommand, string transactionID)
        {
            return ExecuteDataTableNonQueryCommand(typeof(T), commonCommand, transactionID);
        }

        public int ExecuteDataTableNonQueryCommand<T>(CommonCommand commonCommand)
        {
            return ExecuteDataTableNonQueryCommand(typeof(T), commonCommand);
        }

        public System.Data.IDataReader ExecuteDataTableReaderCommand<T>(CommonCommand commonCommand, string transactionID)
        {
            return ExecuteDataTableReaderCommand(typeof(T), commonCommand, transactionID);
        }

        public System.Data.IDataReader ExecuteDataTableReaderCommand<T>(CommonCommand commonCommand)
        {
            return ExecuteDataTableReaderCommand(typeof(T), commonCommand);
        }

        public object ExecuteDataTableScalarCommand<T>(CommonCommand commonCommand)
        {
            return ExecuteDataTableScalarCommand(typeof(T), commonCommand);
        }

        public object ExecuteDataTableScalarCommand<T>(CommonCommand commonCommand, string transactionID)
        {
            return ExecuteDataTableScalarCommand(typeof(T), commonCommand, transactionID);
        }

        public bool Exists<T>(object[] primaryKeys, string transactionID)
        {
            return Exists(typeof(T), primaryKeys, transactionID);
        }

        public bool Exists<T>(object[] primaryKeys)
        {
            return Exists(typeof(T), primaryKeys);
        }

        public int Fill<T>(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return Fill(typeof(T), dataTable, columnNames, conditionCommand, startRecord, maxRecords);
        }

        public int Fill<T>(System.Data.DataTable dataTable, int startRecord, int maxRecords, string transactionID)
        {
            return Fill(typeof(T), dataTable, startRecord, maxRecords, transactionID);
        }

        public int Fill<T>(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return Fill(typeof(T), dataTable, columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public int Fill<T>(System.Data.DataTable dataTable, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return Fill(typeof(T), dataTable, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public int Fill<T>(System.Data.DataTable dataTable, string[] columnNames, int startRecord, int maxRecords, string transactionID)
        {
            return Fill(typeof(T), dataTable, columnNames, startRecord, maxRecords, transactionID);
        }

        public int Fill<T>(System.Data.DataTable dataTable, string[] columnNames, int startRecord, int maxRecords)
        {
            return Fill(typeof(T), dataTable, columnNames, startRecord, maxRecords);
        }

        public int Fill<T>(System.Data.DataTable dataTable, int startRecord, int maxRecords)
        {
            return Fill(typeof(T), dataTable, startRecord, maxRecords);
        }

        public int Fill<T>(System.Data.DataTable dataTable, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return Fill(typeof(T), dataTable, conditionCommand, startRecord, maxRecords);
        }

        public int Fill<T>(System.Data.DataTable dataTable, object[] primaryKeys, string[] columnNames)
        {
            return Fill(typeof(T), dataTable, primaryKeys, columnNames);
        }

        public int Fill<T>(System.Data.DataTable dataTable, object[] primaryKeys)
        {
            return Fill(typeof(T), dataTable, primaryKeys);
        }

        public int Fill<T>(System.Data.DataTable dataTable, string transactionID)
        {
            return Fill(typeof(T), dataTable, transactionID);
        }

        public int Fill<T>(System.Data.DataTable dataTable, string[] columnNames, string transactionID)
        {
            return Fill(typeof(T), dataTable, columnNames, transactionID);
        }

        public int Fill<T>(System.Data.DataTable dataTable, CommonCommand conditionCommand, string transactionID)
        {
            return Fill(typeof(T), dataTable, conditionCommand, transactionID);
        }

        public int Fill<T>(System.Data.DataTable dataTable, string[] columnNames)
        {
            return Fill(typeof(T), dataTable, columnNames);
        }

        public int Fill<T>(System.Data.DataTable dataTable)
        {
            return Fill(typeof(T), dataTable);
        }

        public int Fill<T>(System.Data.DataTable dataTable, CommonCommand conditionCommand)
        {
            return Fill(typeof(T), dataTable, conditionCommand);
        }

        public int Fill<T>(System.Data.DataTable dataTable, object[] primaryKeys, string[] columnNames, string transactionID)
        {
            return Fill(typeof(T), dataTable, primaryKeys, columnNames, transactionID);
        }

        public int Fill<T>(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand)
        {
            return Fill(typeof(T), dataTable, columnNames, conditionCommand);
        }

        public int Fill<T>(System.Data.DataTable dataTable, object[] primaryKeys, string transactionID)
        {
            return Fill(typeof(T), dataTable, primaryKeys, transactionID);
        }

        public int Fill<T>(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return Fill(typeof(T), dataTable, columnNames, conditionCommand, transactionID);
        }

        public int FillDataTable<T>(System.Data.DataTable dataTable, CommonCommand selectCommand)
        {
            return FillDataTable(typeof(T), dataTable, selectCommand);
        }

        public int FillDataTable<T>(System.Data.DataTable dataTable, CommonCommand selectCommand, string transactionID)
        {
            return FillDataTable(typeof(T), dataTable, selectCommand, transactionID);
        }

        public int FillView<T>(System.Data.DataTable dataTable, CommonCommand conditionCommand, string transactionID)
        {
            return FillView(typeof(T), dataTable, conditionCommand, transactionID);
        }

        public int FillView<T>(System.Data.DataTable dataTable, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return FillView(typeof(T), dataTable, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public int FillView<T>(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return FillView(typeof(T), dataTable, columnNames, conditionCommand, transactionID);
        }

        public int FillView<T>(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return FillView(typeof(T), dataTable, columnNames, conditionCommand, transactionID);
        }

        public int FillView<T>(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand)
        {
            return FillView(typeof(T), dataTable, columnNames, conditionCommand);
        }

        public int FillView<T>(System.Data.DataTable dataTable, CommonCommand conditionCommand)
        {
            return FillView(typeof(T), dataTable, conditionCommand);
        }

        public int FillView<T>(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return FillView(typeof(T), dataTable, columnNames, conditionCommand, startRecord, maxRecords);
        }

        public int FillView<T>(System.Data.DataTable dataTable, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return FillView(typeof(T), dataTable, conditionCommand, startRecord, maxRecords);
        }

        public object GetAvgData<T>(string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetAvgData(typeof(T), columnName, conditionCommand, transactionID);
        }

        public object GetAvgData<T>(string columnName, string transactionID)
        {
            return GetAvgData(typeof(T), columnName, transactionID);
        }

        public object GetAvgData<T>(string columnName, CommonCommand conditionCommand)
        {
            return GetAvgData(typeof(T), columnName, conditionCommand);
        }

        public object GetAvgData<T>(string columnName)
        {
            return GetAvgData(typeof(T), columnName);
        }

        public object GetMaxData<T>(string columnName, CommonCommand conditionCommand)
        {
            return GetMaxData(typeof(T), columnName, conditionCommand);
        }

        public object GetMaxData<T>(string columnName)
        {
            return GetMaxData(typeof(T), columnName);
        }

        public object GetMaxData<T>(string columnName, string transactionID)
        {
            return GetMaxData(typeof(T), columnName, transactionID);
        }

        public object GetMaxData<T>(string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetMaxData(typeof(T), columnName, conditionCommand, transactionID);
        }

        public object GetMinData<T>(string columnName, CommonCommand conditionCommand)
        {
            return GetMinData(typeof(T), columnName, conditionCommand);
        }

        public object GetMinData<T>(string columnName, string transactionID)
        {
            return GetMinData(typeof(T), columnName, transactionID);
        }

        public object GetMinData<T>(string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetMinData(typeof(T), columnName, conditionCommand, transactionID);
        }

        public object GetMinData<T>(string columnName)
        {
            return GetMinData(typeof(T), columnName);
        }

        public object GetSumData<T>(string columnName, CommonCommand conditionCommand)
        {
            return GetSumData(typeof(T), columnName, conditionCommand);
        }

        public object GetSumData<T>(string columnName)
        {
            return GetSumData(typeof(T), columnName);
        }

        public object GetSumData<T>(string columnName, string transactionID)
        {
            return GetSumData(typeof(T), columnName, transactionID);
        }

        public object GetSumData<T>(string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetSumData(typeof(T), columnName, conditionCommand, transactionID);
        }

        public int GetDataCount<T>(CommonCommand conditionCommand)
        {
            return GetDataCount(typeof(T), conditionCommand);
        }

        public int GetDataCount<T>(CommonCommand conditionCommand, string transactionID)
        {
            return GetDataCount(typeof(T), conditionCommand, transactionID);
        }

        public int GetDataCount<T>(string transactionID)
        {
            return GetDataCount(typeof(T), transactionID);
        }

        public int GetDataCount<T>()
        {
            return GetDataCount(typeof(T));
        }

        public object GetViewAvgData<T>(string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetViewAvgData(typeof(T), columnName, conditionCommand, transactionID);
        }

        public object GetViewAvgData<T>(string columnName, CommonCommand conditionCommand)
        {
            return GetViewAvgData(typeof(T), columnName, conditionCommand);
        }

        public object GetViewMaxData<T>(string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetViewMaxData(typeof(T), columnName, conditionCommand, transactionID);
        }

        public object GetViewMaxData<T>(string columnName, CommonCommand conditionCommand)
        {
            return GetViewMaxData(typeof(T), columnName, conditionCommand);
        }

        public object GetViewMinData<T>(string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetViewMinData(typeof(T), columnName, conditionCommand, transactionID);
        }

        public object GetViewMinData<T>(string columnName, CommonCommand conditionCommand)
        {
            return GetViewMinData(typeof(T), columnName, conditionCommand);
        }

        public object GetViewSumData<T>(string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetViewSumData(typeof(T), columnName, conditionCommand, transactionID);
        }

        public object GetViewSumData<T>(string columnName, CommonCommand conditionCommand)
        {
            return GetViewSumData(typeof(T), columnName, conditionCommand);
        }

        public int GetViewDataCount<T>(CommonCommand conditionCommand, string transactionID)
        {
            return GetViewDataCount(typeof(T), conditionCommand, transactionID);
        }

        public int GetViewDataCount<T>(CommonCommand conditionCommand)
        {
            return GetViewDataCount(typeof(T), conditionCommand);
        }

        public int Insert<T>(object[] values)
        {
            return Insert(typeof(T), values);
        }

        public int Insert<T>(string[] columnNames, object[] values, string transactionID)
        {
            return Insert(typeof(T), columnNames, values, transactionID);
        }

        public int Insert<T>(System.Collections.Generic.Dictionary<string, object> values, string transactionID)
        {
            return Insert(typeof(T), values, transactionID);
        }

        public int Insert<T>(object[] values, string transactionID)
        {
            return Insert(typeof(T), values, transactionID);
        }

        public int Insert<T>(string[] columnNames, object[] values)
        {
            return Insert(typeof(T), columnNames, values);
        }

        public int Insert<T>(System.Collections.Generic.Dictionary<string, object> values)
        {
            return Insert(typeof(T), values);
        }

        public int Save<T>(object[] values)
        {
            return Save(typeof(T), values);
        }

        public int Save<T>(object[] values, string transactionID)
        {
            return Save(typeof(T), values, transactionID);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, string[] columnNames, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(typeof(T), dataRows, columnNames, updateBehavior, transactionID);
        }

        public int Update<T>(System.Data.DataTable dataTable, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(typeof(T), dataTable, checkConcurrency, updateBehavior, transactionID);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, string[] columnNames, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(typeof(T), dataRows, columnNames, checkConcurrency, updateBehavior, transactionID);
        }

        public int Update<T>(CommonCommand conditionCommand, object[] values)
        {
            return Update(typeof(T), conditionCommand, values);
        }

        public int Update<T>(System.Data.DataTable dataTable, string[] columnNames, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(typeof(T), dataTable, columnNames, checkConcurrency, updateBehavior, transactionID);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(typeof(T), dataRows, checkConcurrency, updateBehavior, transactionID);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(typeof(T), dataRows, updateBehavior, transactionID);
        }

        public int Update<T>(System.Data.DataRow dataRow, bool checkConcurrency, string transactionID)
        {
            return Update(typeof(T), dataRow, checkConcurrency, transactionID);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, string[] columnNames, bool checkConcurrency, string transactionID)
        {
            return Update(typeof(T), dataRows, columnNames, checkConcurrency, transactionID);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, bool checkConcurrency, string transactionID)
        {
            return Update(typeof(T), dataRows, checkConcurrency, transactionID);
        }

        public int Update<T>(System.Data.DataTable dataTable, string[] columnNames, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(typeof(T), dataTable, columnNames, updateBehavior, transactionID);
        }

        public int Update<T>(System.Data.DataTable dataTable, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(typeof(T), dataTable, updateBehavior, transactionID);
        }

        public int Update<T>(System.Data.DataRow dataRow, string[] columnNames, bool checkConcurrency, string transactionID)
        {
            return Update(typeof(T), dataRow, columnNames, checkConcurrency, transactionID);
        }

        public int Update<T>(System.Data.DataTable dataTable, string[] columnNames)
        {
            return Update(typeof(T), dataTable, columnNames);
        }

        public int Update<T>(System.Data.DataTable dataTable)
        {
            return Update(typeof(T), dataTable);
        }

        public int Update<T>(System.Data.DataRow dataRow, string[] columnNames)
        {
            return Update(typeof(T), dataRow, columnNames);
        }

        public int Update<T>(System.Data.DataRow[] dataRows)
        {
            return Update(typeof(T), dataRows);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, string[] columnNames)
        {
            return Update(typeof(T), dataRows, columnNames);
        }

        public int Update<T>(System.Data.DataRow dataRow)
        {
            return Update(typeof(T), dataRow);
        }

        public int Update<T>(object[] values)
        {
            return Update(typeof(T), values);
        }

        public int Update<T>(object[] primaryKeys, System.Collections.Generic.Dictionary<string, object> values)
        {
            return Update(typeof(T), primaryKeys, values);
        }

        public int Update<T>(string[] columnNames, object[] originalValues, object[] values)
        {
            return Update(typeof(T), columnNames, originalValues, values);
        }

        public int Update<T>(System.Collections.Generic.Dictionary<string, object> originalValues, System.Collections.Generic.Dictionary<string, object> values)
        {
            return Update(typeof(T), originalValues, values);
        }

        public int Update<T>(object[] primaryKeys, string[] columnNames, object[] values)
        {
            return Update(typeof(T), primaryKeys, values);
        }

        public int Update<T>(string[] columnNames, object[] values)
        {
            return Update(typeof(T), columnNames, values);
        }

        public int Update<T>(System.Collections.Generic.Dictionary<string, object> values)
        {
            return Update(typeof(T), values);
        }

        public int Update<T>(object[] primaryKeys, object[] values)
        {
            return Update(typeof(T), primaryKeys, values);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, UpdateBehavior updateBehavior)
        {
            return Update(typeof(T), dataRows, updateBehavior);
        }

        public int Update<T>(object[] values, string transactionID)
        {
            return Update(typeof(T), values, transactionID);
        }

        public int Update<T>(System.Data.DataTable dataTable, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return Update(typeof(T), dataTable, checkConcurrency, updateBehavior);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, string[] columnNames, UpdateBehavior updateBehavior)
        {
            return Update(typeof(T), dataRows, columnNames, updateBehavior);
        }

        public int Update<T>(string[] columnNames, object[] values, string transactionID)
        {
            return Update(typeof(T), columnNames, transactionID);
        }

        public int Update<T>(object[] primaryKeys, string[] columnNames, object[] values, string transactionID)
        {
            return Update(typeof(T), primaryKeys, columnNames, values, transactionID);
        }

        public int Update<T>(object[] primaryKeys, System.Collections.Generic.Dictionary<string, object> values, string transactionID)
        {
            return Update(typeof(T), primaryKeys, values, transactionID);
        }

        public int Update<T>(System.Collections.Generic.Dictionary<string, object> values, string transactionID)
        {
            return Update(typeof(T), values, transactionID);
        }

        public int Update<T>(object[] primaryKeys, object[] values, string transactionID)
        {
            return Update(typeof(T), primaryKeys, values, transactionID);
        }

        public int Update<T>(System.Data.DataTable dataTable, string[] columnNames, string transactionID)
        {
            return Update(typeof(T), dataTable, columnNames, transactionID);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, string transactionID)
        {
            return Update(typeof(T), dataRows, transactionID);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, string[] columnNames, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return Update(typeof(T), dataRows, columnNames, checkConcurrency, updateBehavior);
        }

        public int Update<T>(System.Data.DataTable dataTable, string transactionID)
        {
            return Update(typeof(T), dataTable, transactionID);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, string[] columnNames, string transactionID)
        {
            return Update(typeof(T), dataRows, columnNames, transactionID);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return Update(typeof(T), dataRows, checkConcurrency, updateBehavior);
        }

        public int Update<T>(System.Data.DataTable dataTable, string[] columnNames, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return Update(typeof(T), dataTable, columnNames, checkConcurrency, updateBehavior);
        }

        public int Update<T>(System.Data.DataRow dataRow, string transactionID)
        {
            return Update(typeof(T), dataRow, transactionID);
        }

        public int Update<T>(System.Data.DataRow dataRow, string[] columnNames, string transactionID)
        {
            return Update(typeof(T), dataRow, columnNames, transactionID);
        }

        public int Update<T>(string[] columnNames, object[] originalValues, object[] values, string transactionID)
        {
            return Update(typeof(T), columnNames, originalValues, values, transactionID);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, bool checkConcurrency)
        {
            return Update(typeof(T), dataRows, checkConcurrency);
        }

        public int Update<T>(System.Data.DataTable dataTable, string[] columnNames, bool checkConcurrency)
        {
            return Update(typeof(T), dataTable, columnNames, checkConcurrency);
        }

        public int Update<T>(System.Data.DataRow dataRow, bool checkConcurrency)
        {
            return Update(typeof(T), dataRow, checkConcurrency);
        }

        public int Update<T>(System.Data.DataRow[] dataRows, string[] columnNames, bool checkConcurrency)
        {
            return Update(typeof(T), dataRows, columnNames, checkConcurrency);
        }

        public int Update<T>(System.Data.DataTable dataTable, bool checkConcurrency)
        {
            return Update(typeof(T), dataTable, checkConcurrency);
        }

        public int Update<T>(System.Data.DataTable dataTable, bool checkConcurrency, string transactionID)
        {
            return Update(typeof(T), dataTable, checkConcurrency, transactionID);
        }

        public int Update<T>(System.Data.DataTable dataTable, string[] columnNames, bool checkConcurrency, string transactionID)
        {
            return Update(typeof(T), dataTable, columnNames, checkConcurrency, transactionID);
        }

        public int Update<T>(CommonCommand conditionCommand, System.Collections.Generic.Dictionary<string, object> values)
        {
            return Update(typeof(T), conditionCommand, values);
        }

        public int Update<T>(CommonCommand conditionCommand, string[] columnNames, object[] values)
        {
            return Update(typeof(T), conditionCommand, columnNames, values);
        }

        public int Update<T>(CommonCommand conditionCommand, string[] columnNames, object[] values, string transactionID)
        {
            return Update(typeof(T), conditionCommand, columnNames, values, transactionID);
        }

        public int Update<T>(CommonCommand conditionCommand, object[] values, string transactionID)
        {
            return Update(typeof(T), conditionCommand, values, transactionID);
        }

        public int Update<T>(System.Collections.Generic.Dictionary<string, object> originalValues, System.Collections.Generic.Dictionary<string, object> values, string transactionID)
        {
            return Update(typeof(T), originalValues, values, transactionID);
        }

        public int Update<T>(CommonCommand conditionCommand, System.Collections.Generic.Dictionary<string, object> values, string transactionID)
        {
            return Update(typeof(T), conditionCommand, values, transactionID);
        }

        public int Update<T>(System.Data.DataRow dataRow, string[] columnNames, bool checkConcurrency)
        {
            return Update(typeof(T), dataRow, columnNames, checkConcurrency);
        }

        public int Update<T>(System.Data.DataTable dataTable, UpdateBehavior updateBehavior)
        {
            return Update(typeof(T), dataTable, updateBehavior);
        }

        public int Update<T>(System.Data.DataTable dataTable, string[] columnNames, UpdateBehavior updateBehavior)
        {
            return Update(typeof(T), dataTable, columnNames, updateBehavior);
        }

        public int UpdateDataTable<T>(System.Data.DataTable dataTable, CommonCommand insertCommand, CommonCommand updateCommand, CommonCommand deleteCommand, UpdateBehavior updateBehavior)
        {
            return UpdateDataTable(typeof(T), dataTable, insertCommand, updateCommand, deleteCommand, updateBehavior);
        }

        public int UpdateDataTable<T>(System.Data.DataTable dataTable, CommonCommand insertCommand, CommonCommand updateCommand, CommonCommand deleteCommand)
        {
            return UpdateDataTable(typeof(T), dataTable, insertCommand, updateCommand, deleteCommand);
        }

        public int UpdateDataTable<T>(System.Data.DataTable dataTable, CommonCommand insertCommand, CommonCommand updateCommand, CommonCommand deleteCommand, UpdateBehavior updateBehavior, string transactionID)
        {
            return UpdateDataTable(typeof(T), dataTable, insertCommand, updateCommand, deleteCommand, updateBehavior, transactionID);
        }

        public int UpdateDataTable<T>(System.Data.DataTable dataTable, CommonCommand insertCommand, CommonCommand updateCommand, CommonCommand deleteCommand, string transactionID)
        {
            return UpdateDataTable(typeof(T), dataTable, insertCommand, updateCommand, deleteCommand, transactionID);
        }
        #endregion
        #region DataObject Functions
        public T GetDataObject<T>(object dataObject, string[] columnNames, string transactionID)
        {
            return (T)GetDataObject(typeof(T), dataObject, columnNames, transactionID);
        }

        public T GetDataObject<T>(object[] primaryKeys)
        {
            return (T)GetDataObject(typeof(T), primaryKeys);
        }

        public T GetDataObject<T>(object[] primaryKeys, string[] columnNames, string transactionID)
        {
            return (T)GetDataObject(typeof(T), primaryKeys, columnNames, transactionID);
        }

        public T GetDataObject<T>(object[] primaryKeys, string transactionID)
        {
            return (T)GetDataObject(typeof(T), primaryKeys, transactionID);
        }

        public T GetDataObject<T>(object dataObject, string transactionID)
        {
            return (T)GetDataObject(typeof(T), dataObject, transactionID);
        }

        public T GetDataObject<T>(object[] primaryKeys, string[] columnNames)
        {
            return (T)GetDataObject(typeof(T), primaryKeys, columnNames);
        }

        public T GetDataObject<T>(object dataObject, string[] columnNames)
        {
            return (T)GetDataObject(typeof(T), dataObject, columnNames);
        }

        public T GetDataObject<T>(object dataObject)
        {
            return (T)GetDataObject(typeof(T), dataObject);
        }


        public int DeleteDataObject<T>(object dataObject)
        {
            return DeleteDataObject(typeof(T), dataObject);
        }

        public int DeleteDataObject<T>(object dataObject, string transactionID)
        {
            return DeleteDataObject(typeof(T), dataObject, transactionID);
        }

        public bool ExistsDataObject<T>(object dataObject)
        {
            return ExistsDataObject(typeof(T), dataObject);
        }

        public bool ExistsDataObject<T>(object dataObject, string transactionID)
        {
            return ExistsDataObject(typeof(T), dataObject, transactionID);
        }

        public int FillDataObject<T>(object dataObject, string transactionID)
        {
            return FillDataObject(typeof(T), dataObject, transactionID);
        }

        public int FillDataObject<T>(object dataObject, object[] primaryKeys, string transactionID)
        {
            return FillDataObject(typeof(T), dataObject, primaryKeys, transactionID);
        }

        public int FillDataObject<T>(object dataObject, string[] columnNames, string transactionID)
        {
            return FillDataObject(typeof(T), dataObject, columnNames, transactionID);
        }

        public int FillDataObject<T>(object dataObject, object[] primaryKeys, string[] columnNames, string transactionID)
        {
            return FillDataObject(typeof(T), dataObject, primaryKeys, columnNames, transactionID);
        }

        public int FillDataObject<T>(object dataObject, object[] primaryKeys, string[] columnNames)
        {
            return FillDataObject(typeof(T), dataObject, primaryKeys, columnNames);
        }

        public int FillDataObject<T>(object dataObject, string[] columnNames)
        {
            return FillDataObject(typeof(T), dataObject, columnNames);
        }

        public int FillDataObject<T>(object dataObject, object[] primaryKeys)
        {
            return FillDataObject(typeof(T), dataObject, primaryKeys);
        }

        public int FillDataObject<T>(object dataObject)
        {
            return FillDataObject(typeof(T), dataObject);
        }

        public System.Collections.IList GetDataObjectList<T>(string[] columnNames, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectList(typeof(T), columnNames, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataObjectList<T>(int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectList(typeof(T), startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataObjectList<T>(CommonCommand conditionCommand, string transactionID)
        {
            return GetDataObjectList(typeof(T), conditionCommand, transactionID);
        }

        public System.Collections.IList GetDataObjectList<T>(string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataObjectList(typeof(T), columnNames, conditionCommand, transactionID);
        }

        public System.Collections.IList GetDataObjectList<T>(string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectList(typeof(T), columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataObjectList<T>(CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectList(typeof(T), conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataObjectList<T>(string[] columnNames, string transactionID)
        {
            return GetDataObjectList(typeof(T), columnNames, transactionID);
        }

        public System.Collections.IList GetDataObjectList<T>(string transactionID)
        {
            return GetDataObjectList(typeof(T), transactionID);
        }

        public System.Collections.IList GetDataObjectList<T>(string[] columnNames, int startRecord, int maxRecords)
        {
            return GetDataObjectList(typeof(T), columnNames, startRecord, maxRecords);
        }

        public System.Collections.IList GetDataObjectList<T>(int startRecord, int maxRecords)
        {
            return GetDataObjectList(typeof(T), startRecord, maxRecords);
        }

        public System.Collections.IList GetDataObjectList<T>(string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataObjectList(typeof(T), columnNames, conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IList GetDataObjectList<T>(CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataObjectList(typeof(T), conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IList GetDataObjectList<T>(string[] columnNames)
        {
            return GetDataObjectList(typeof(T), columnNames);
        }

        public System.Collections.IList GetDataObjectList<T>()
        {
            return GetDataObjectList(typeof(T));
        }

        public System.Collections.IList GetDataObjectList<T>(string[] columnNames, CommonCommand conditionCommand)
        {
            return GetDataObjectList(typeof(T), columnNames, conditionCommand);
        }

        public System.Collections.IList GetDataObjectList<T>(CommonCommand conditionCommand)
        {
            return GetDataObjectList(typeof(T), conditionCommand);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(string[] columnNames, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectEnumerator(typeof(T), columnNames, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectEnumerator(typeof(T), startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectEnumerator(typeof(T), columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectEnumerator(typeof(T), conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(string[] columnNames, string transactionID)
        {
            return GetDataObjectEnumerator(typeof(T), columnNames, transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(string transactionID)
        {
            return GetDataObjectEnumerator(typeof(T), transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataObjectEnumerator(typeof(T), columnNames, conditionCommand, transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(CommonCommand conditionCommand, string transactionID)
        {
            return GetDataObjectEnumerator(typeof(T), conditionCommand, transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(string[] columnNames, int startRecord, int maxRecords)
        {
            return GetDataObjectEnumerator(typeof(T), columnNames, startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(int startRecord, int maxRecords)
        {
            return GetDataObjectEnumerator(typeof(T), startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataObjectEnumerator(typeof(T), columnNames, conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataObjectEnumerator(typeof(T), conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(string[] columnNames)
        {
            return GetDataObjectEnumerator(typeof(T), columnNames);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>()
        {
            return GetDataObjectEnumerator(typeof(T));
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(string[] columnNames, CommonCommand conditionCommand)
        {
            return GetDataObjectEnumerator(typeof(T), columnNames, conditionCommand);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator<T>(CommonCommand conditionCommand)
        {
            return GetDataObjectEnumerator(typeof(T), conditionCommand);
        }

        public int InsertDataObject<T>(object dataObject, string[] columnNames)
        {
            return InsertDataObject(typeof(T), dataObject, columnNames);
        }

        public int InsertDataObject<T>(object dataObject)
        {
            return InsertDataObject(typeof(T), dataObject);
        }

        public int InsertDataObject<T>(object dataObject, string[] columnNames, string transactionID)
        {
            return InsertDataObject(typeof(T), dataObject, columnNames, transactionID);
        }

        public int InsertDataObject<T>(object dataObject, string transactionID)
        {
            return InsertDataObject(typeof(T), dataObject, transactionID);
        }

        public int SaveDataObject<T>(object dataObject, string transactionID)
        {
            return SaveDataObject(typeof(T), dataObject, transactionID);
        }

        public int SaveDataObject<T>(object dataObject, string[] columnNames)
        {
            return SaveDataObject(typeof(T), dataObject, columnNames);
        }

        public int SaveDataObject<T>(object dataObject, string[] columnNames, string transactionID)
        {
            return SaveDataObject(typeof(T), dataObject, columnNames, transactionID);
        }

        public int SaveDataObject<T>(object dataObject)
        {
            return SaveDataObject(typeof(T), dataObject);
        }

        public int UpdateDataObject<T>(object dataObject, string transactionID)
        {
            return UpdateDataObject(typeof(T), dataObject, transactionID);
        }

        public int UpdateDataObject<T>(object[] primaryKeys, object dataObject, string[] columnNames)
        {
            return UpdateDataObject(typeof(T), primaryKeys, dataObject, columnNames);
        }

        public int UpdateDataObject<T>(object dataObject, string[] columnNames)
        {
            return UpdateDataObject(typeof(T), dataObject, columnNames);
        }

        public int UpdateDataObject<T>(object[] primaryKeys, object dataObject)
        {
            return UpdateDataObject(typeof(T), primaryKeys, dataObject);
        }

        public int UpdateDataObject<T>(object dataObject)
        {
            return UpdateDataObject(typeof(T), dataObject);
        }

        public int UpdateDataObject<T>(object[] primaryKeys, object dataObject, string[] columnNames, string transactionID)
        {
            return UpdateDataObject(typeof(T), primaryKeys, dataObject, columnNames, transactionID);
        }

        public int UpdateDataObject<T>(object[] primaryKeys, object dataObject, string transactionID)
        {
            return UpdateDataObject(typeof(T), primaryKeys, dataObject, transactionID);
        }

        public int UpdateDataObject<T>(object dataObject, string[] columnNames, string transactionID)
        {
            return UpdateDataObject(typeof(T), dataObject, columnNames, transactionID);
        }
        #endregion
        #region DataItem Functions
        public T GetDataItem<T>(object[] primaryKeys, string transactionID) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItem(typeof(T), primaryKeys, transactionID);
        }

        public T GetDataItem<T>(object[] primaryKeys) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItem(typeof(T), primaryKeys);
        }

        public T GetDataItem<T>(DataItem dataItem, string[] columnNames, string transactionID) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItem(typeof(T), dataItem, columnNames, transactionID);
        }

        public T GetDataItem<T>(DataItem dataItem, string transactionID) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItem(typeof(T), dataItem, transactionID);
        }

        public T GetDataItem<T>(object[] primaryKeys, string[] columnNames, string transactionID) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItem(typeof(T), primaryKeys, columnNames, transactionID);
        }

        public T GetDataItem<T>(DataItem dataItem) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItem(typeof(T), dataItem);
        }

        public T GetDataItem<T>(DataItem dataItem, string[] columnNames) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItem(typeof(T), dataItem, columnNames);
        }

        public T GetDataItem<T>(object[] primaryKeys, string[] columnNames) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItem(typeof(T), primaryKeys, columnNames);
        }


        public int DeleteDataItem<T>(DataItem dataItem)
        {
            return DeleteDataItem(typeof(T), dataItem);
        }

        public int DeleteDataItem<T>(DataItem dataItem, string transactionID)
        {
            return DeleteDataItem(typeof(T), dataItem, transactionID);
        }

        public bool ExistsDataItem<T>(DataItem dataItem, string transactionID)
        {
            return ExistsDataItem(typeof(T), dataItem, transactionID);
        }

        public bool ExistsDataItem<T>(DataItem dataItem)
        {
            return ExistsDataItem(typeof(T), dataItem);
        }

        public int FillDataItem<T>(DataItem dataItem, object[] primaryKeys)
        {
            return FillDataItem(typeof(T), dataItem, primaryKeys);
        }

        public int FillDataItem<T>(DataItem dataItem, string transactionID)
        {
            return FillDataItem(typeof(T), dataItem, transactionID);
        }

        public int FillDataItem<T>(DataItem dataItem, object[] primaryKeys, string transactionID)
        {
            return FillDataItem(typeof(T), dataItem, primaryKeys, transactionID);
        }

        public int FillDataItem<T>(DataItem dataItem, string[] columnNames, string transactionID)
        {
            return FillDataItem(typeof(T), dataItem, columnNames, transactionID);
        }

        public int FillDataItem<T>(DataItem dataItem, object[] primaryKeys, string[] columnNames, string transactionID)
        {
            return FillDataItem(typeof(T), dataItem, primaryKeys, columnNames, transactionID);
        }

        public int FillDataItem<T>(DataItem dataItem, string[] columnNames)
        {
            return FillDataItem(typeof(T), dataItem, columnNames);
        }

        public int FillDataItem<T>(DataItem dataItem, object[] primaryKeys, string[] columnNames)
        {
            return FillDataItem(typeof(T), dataItem, primaryKeys, columnNames);
        }

        public int FillDataItem<T>(DataItem dataItem)
        {
            return FillDataItem(typeof(T), dataItem);
        }

        public System.Collections.IList GetDataItemList<T>(string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataItemList(typeof(T), columnNames, conditionCommand, transactionID);
        }

        public System.Collections.IList GetDataItemList<T>(string[] columnNames, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemList(typeof(T), columnNames, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataItemList<T>(CommonCommand conditionCommand, string transactionID)
        {
            return GetDataItemList(typeof(T), conditionCommand, transactionID);
        }

        public System.Collections.IList GetDataItemList<T>(string transactionID)
        {
            return GetDataItemList(typeof(T), transactionID);
        }

        public System.Collections.IList GetDataItemList<T>(string[] columnNames, string transactionID)
        {
            return GetDataItemList(typeof(T), columnNames, transactionID);
        }

        public System.Collections.IList GetDataItemList<T>(int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemList(typeof(T), startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataItemList<T>(string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemList(typeof(T), columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataItemList<T>(CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemList(typeof(T), conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataItemList<T>(string[] columnNames, int startRecord, int maxRecords)
        {
            return GetDataItemList(typeof(T), columnNames, startRecord, maxRecords);
        }

        public System.Collections.IList GetDataItemList<T>(int startRecord, int maxRecords)
        {
            return GetDataItemList(typeof(T), startRecord, maxRecords);
        }

        public System.Collections.IList GetDataItemList<T>(string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataItemList(typeof(T), columnNames, conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IList GetDataItemList<T>(CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataItemList(typeof(T), conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IList GetDataItemList<T>(string[] columnNames)
        {
            return GetDataItemList(typeof(T), columnNames);
        }

        public System.Collections.IList GetDataItemList<T>()
        {
            return GetDataItemList(typeof(T));
        }

        public System.Collections.IList GetDataItemList<T>(string[] columnNames, CommonCommand conditionCommand)
        {
            return GetDataItemList(typeof(T), columnNames, conditionCommand);
        }

        public System.Collections.IList GetDataItemList<T>(CommonCommand conditionCommand)
        {
            return GetDataItemList(typeof(T), conditionCommand);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(string[] columnNames, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemEnumerator(typeof(T), columnNames, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemEnumerator(typeof(T), startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemEnumerator(typeof(T), columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemEnumerator(typeof(T), conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(string[] columnNames, string transactionID)
        {
            return GetDataItemEnumerator(typeof(T), columnNames, transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(string transactionID)
        {
            return GetDataItemEnumerator(typeof(T), transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataItemEnumerator(typeof(T), columnNames, conditionCommand, transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(CommonCommand conditionCommand, string transactionID)
        {
            return GetDataItemEnumerator(typeof(T), conditionCommand, transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataItemEnumerator(typeof(T), conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(string[] columnNames, int startRecord, int maxRecords)
        {
            return GetDataItemEnumerator(typeof(T), columnNames, startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>()
        {
            return GetDataItemEnumerator(typeof(T));
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataItemEnumerator(typeof(T), columnNames, conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(CommonCommand conditionCommand)
        {
            return GetDataItemEnumerator(typeof(T), conditionCommand);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(string[] columnNames)
        {
            return GetDataItemEnumerator(typeof(T), columnNames);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(int startRecord, int maxRecords)
        {
            return GetDataItemEnumerator(typeof(T), startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator<T>(string[] columnNames, CommonCommand conditionCommand)
        {
            return GetDataItemEnumerator(typeof(T), columnNames, conditionCommand);
        }

        public int InsertDataItem<T>(DataItem dataItem)
        {
            return InsertDataItem(typeof(T), dataItem);
        }

        public int InsertDataItem<T>(DataItem dataItem, string[] columnNames)
        {
            return InsertDataItem(typeof(T), dataItem, columnNames);
        }

        public int InsertDataItem<T>(DataItem dataItem, string transactionID)
        {
            return InsertDataItem(typeof(T), dataItem, transactionID);
        }

        public int InsertDataItem<T>(DataItem dataItem, string[] columnNames, string transactionID)
        {
            return InsertDataItem(typeof(T), dataItem, columnNames, transactionID);
        }

        public int SaveDataItem<T>(DataItem dataItem, string[] columnNames, string transactionID)
        {
            return SaveDataItem(typeof(T), dataItem, columnNames, transactionID);
        }

        public int SaveDataItem<T>(DataItem dataItem)
        {
            return SaveDataItem(typeof(T), dataItem);
        }

        public int SaveDataItem<T>(DataItem dataItem, string[] columnNames)
        {
            return SaveDataItem(typeof(T), dataItem, columnNames);
        }

        public int SaveDataItem<T>(DataItem dataItem, string transactionID)
        {
            return SaveDataItem(typeof(T), dataItem, transactionID);
        }

        public int UpdateDataItem<T>(object[] primaryKeys, DataItem dataItem, string transactionID)
        {
            return UpdateDataItem(typeof(T), primaryKeys, dataItem, transactionID);
        }

        public int UpdateDataItem<T>(DataItem dataItem, string transactionID)
        {
            return UpdateDataItem(typeof(T), dataItem, transactionID);
        }

        public int UpdateDataItem<T>(object[] primaryKeys, DataItem dataItem, string[] columnNames)
        {
            return UpdateDataItem(typeof(T), primaryKeys, dataItem, columnNames);
        }

        public int UpdateDataItem<T>(object[] primaryKeys, DataItem dataItem)
        {
            return UpdateDataItem(typeof(T), primaryKeys, dataItem);
        }

        public int UpdateDataItem<T>(DataItem dataItem)
        {
            return UpdateDataItem(typeof(T), dataItem);
        }

        public int UpdateDataItem<T>(DataItem dataItem, string[] columnNames)
        {
            return UpdateDataItem(typeof(T), dataItem, columnNames);
        }

        public int UpdateDataItem<T>(DataItem dataItem, string[] columnNames, string transactionID)
        {
            return UpdateDataItem(typeof(T), dataItem, columnNames, transactionID);
        }

        public int UpdateDataItem<T>(object[] primaryKeys, DataItem dataItem, string[] columnNames, string transactionID)
        {
            return UpdateDataItem(typeof(T), primaryKeys, dataItem, columnNames, transactionID);
        }
        #endregion
        #region DataSet Functions
        public T GetDataSet<T>(string[] tableNames, string transactionID) where T : System.Data.DataSet
        {
            return (T)GetDataSet(typeof(T), tableNames, transactionID);
        }

        public T GetDataSet<T>(string transactionID) where T : System.Data.DataSet
        {
            return (T)GetDataSet(typeof(T), transactionID);
        }

        public T GetDataSet<T>(System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary) where T : System.Data.DataSet
        {
            return (T)GetDataSet(typeof(T), columnNamesDictionary);
        }

        public T GetDataSet<T>(string[] tableNames) where T : System.Data.DataSet
        {
            return (T)GetDataSet(typeof(T), tableNames);
        }

        public T GetDataSet<T>() where T : System.Data.DataSet
        {
            return (T)GetDataSet(typeof(T));
        }

        public T GetDataSet<T>(System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID) where T : System.Data.DataSet
        {
            return (T)GetDataSet(typeof(T), columnNamesDictionary, transactionID);
        }

        public T GetDataSet<T>(string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary) where T : System.Data.DataSet
        {
            return (T)GetDataSet(typeof(T), tableNames, columnNamesDictionary);
        }

        public T GetDataSet<T>(string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID) where T : System.Data.DataSet
        {
            return (T)GetDataSet(typeof(T), tableNames, columnNamesDictionary, transactionID);
        }

        public T GetDataByRelation<T>(string tableName, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, CommonCommand conditionCommand, bool viewMode, string transactionID) where T : System.Data.DataSet
        {
            return (T)GetDataByRelation(typeof(T), tableName, columnNamesDictionary, conditionCommand, viewMode, transactionID);
        }

        public T GetDataByRelation<T>(string tableName, object[] primaryKeys, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, bool viewMode, string transactionID) where T : System.Data.DataSet
        {
            return (T)GetDataByRelation(typeof(T), tableName, primaryKeys, columnNamesDictionary, viewMode, transactionID);
        }

        public T GetDataByRelation<T>(string tableName, object[] primaryKeys, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, bool viewMode) where T : System.Data.DataSet
        {
            return (T)GetDataByRelation(typeof(T), tableName, primaryKeys, columnNamesDictionary, viewMode);
        }

        public T GetDataByRelation<T>(string tableName, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, CommonCommand conditionCommand, bool viewMode) where T : System.Data.DataSet
        {
            return (T)GetDataByRelation(typeof(T), tableName, columnNamesDictionary, conditionCommand, viewMode);
        }


        public int DeleteByRelation<T>(string tableName, object[] primaryKeys)
        {
            return DeleteByRelation(typeof(T), tableName, primaryKeys);
        }

        public int DeleteByRelation<T>(string tableName, CommonCommand conditionCommand)
        {
            return DeleteByRelation(typeof(T), tableName, conditionCommand);
        }

        public int DeleteByRelation<T>(string tableName, object[] primaryKeys, string transactionID)
        {
            return DeleteByRelation(typeof(T), tableName, primaryKeys, transactionID);
        }

        public int DeleteByRelation<T>(string tableName, CommonCommand conditionCommand, string transactionID)
        {
            return DeleteByRelation(typeof(T), tableName, conditionCommand, transactionID);
        }

        public int ExecuteDataSetNonQueryCommand<T>(CommonCommand commonCommand, string transactionID)
        {
            return ExecuteDataSetNonQueryCommand(typeof(T), commonCommand, transactionID);
        }

        public int ExecuteDataSetNonQueryCommand<T>(CommonCommand commonCommand)
        {
            return ExecuteDataSetNonQueryCommand(typeof(T), commonCommand);
        }

        public System.Data.IDataReader ExecuteDataSetReaderCommand<T>(CommonCommand commonCommand)
        {
            return ExecuteDataSetReaderCommand(typeof(T), commonCommand);
        }

        public System.Data.IDataReader ExecuteDataSetReaderCommand<T>(CommonCommand commonCommand, string transactionID)
        {
            return ExecuteDataSetReaderCommand(typeof(T), commonCommand, transactionID);
        }

        public object ExecuteDataSetScalarCommand<T>(CommonCommand commonCommand, string transactionID)
        {
            return ExecuteDataSetScalarCommand(typeof(T), commonCommand, transactionID);
        }

        public object ExecuteDataSetScalarCommand<T>(CommonCommand commonCommand)
        {
            return ExecuteDataSetScalarCommand(typeof(T), commonCommand);
        }

        public int Fill<T>(System.Data.DataSet dataSet, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID)
        {
            return Fill(typeof(T), dataSet, columnNamesDictionary, transactionID);
        }

        public int Fill<T>(System.Data.DataSet dataSet, string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary)
        {
            return Fill(typeof(T), dataSet, tableNames, columnNamesDictionary);
        }

        public int Fill<T>(System.Data.DataSet dataSet, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary)
        {
            return Fill(typeof(T), dataSet, columnNamesDictionary);
        }

        public int Fill<T>(System.Data.DataSet dataSet, string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID)
        {
            return Fill(typeof(T), dataSet, tableNames, columnNamesDictionary, transactionID);
        }

        public int Fill<T>(System.Data.DataSet dataSet, string transactionID)
        {
            return Fill(typeof(T), dataSet, transactionID);
        }

        public int Fill<T>(System.Data.DataSet dataSet, string[] tableNames, string transactionID)
        {
            return Fill(typeof(T), dataSet, tableNames, transactionID);
        }

        public int Fill<T>(System.Data.DataSet dataSet, string[] tableNames)
        {
            return Fill(typeof(T), dataSet, tableNames);
        }

        public int Fill<T>(System.Data.DataSet dataSet)
        {
            return Fill(typeof(T), dataSet);
        }

        public int FillByRelation<T>(System.Data.DataSet dataSet, string tableName, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, CommonCommand conditionCommand, bool viewMode)
        {
            return FillByRelation(typeof(T), dataSet, tableName, columnNamesDictionary, conditionCommand, viewMode);
        }

        public int FillByRelation<T>(System.Data.DataSet dataSet, string tableName, object[] primaryKeys, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, bool viewMode)
        {
            return FillByRelation(typeof(T), dataSet, tableName, primaryKeys, columnNamesDictionary, viewMode);
        }

        public int FillByRelation<T>(System.Data.DataSet dataSet, string tableName, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, CommonCommand conditionCommand, bool viewMode, string transactionID)
        {
            return FillByRelation(typeof(T), dataSet, tableName, columnNamesDictionary, conditionCommand, viewMode, transactionID);
        }

        public int FillByRelation<T>(System.Data.DataSet dataSet, string tableName, object[] primaryKeys, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, bool viewMode, string transactionID)
        {
            return FillByRelation(typeof(T), dataSet, tableName, primaryKeys, columnNamesDictionary, viewMode, transactionID);
        }

        public int Update<T>(System.Data.DataSet dataSet, string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary)
        {
            return Update(typeof(T), dataSet, tableNames, columnNamesDictionary);
        }

        public int Update<T>(System.Data.DataSet dataSet, string transactionID)
        {
            return Update(typeof(T), dataSet, transactionID);
        }

        public int Update<T>(System.Data.DataSet dataSet, string[] tableNames, string transactionID)
        {
            return Update(typeof(T), dataSet, tableNames, transactionID);
        }

        public int Update<T>(System.Data.DataSet dataSet, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary)
        {
            return Update(typeof(T), dataSet, columnNamesDictionary);
        }

        public int Update<T>(System.Data.DataSet dataSet, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID)
        {
            return Update(typeof(T), dataSet, columnNamesDictionary);
        }

        public int Update<T>(System.Data.DataSet dataSet, string[] tableNames)
        {
            return Update(typeof(T), dataSet, tableNames);
        }

        public int Update<T>(System.Data.DataSet dataSet)
        {
            return Update(typeof(T), dataSet);
        }

        public int Update<T>(System.Data.DataSet dataSet, string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID)
        {
            return Update(typeof(T), dataSet, tableNames, columnNamesDictionary, transactionID);
        }
        #endregion

        #region Extension Functions
        #region DataTable Functions 
        #region Common Methods
        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill<T>(System.Data.DataTable dataTable, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return Fill(typeof(T), dataTable, conditionExpression);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return Fill(typeof(T), dataTable, columnExpressions, conditionExpression);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillByPrimaryKey<T>(System.Data.DataTable dataTable, object primaryKey)
        {
            return FillByPrimaryKey(typeof(T), dataTable, primaryKey);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillByPrimaryKey<T>(System.Data.DataTable dataTable, object primaryKey, ColumnExpression[] columnExpressions)
        {
            return FillByPrimaryKey(typeof(T), dataTable, primaryKey, columnExpressions);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTable<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), conditionExpression);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTable<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnExpressions, conditionExpression);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTableByPrimaryKey<T>(object primaryKey) where T : System.Data.DataTable
        {
            return (T)GetDataTableByPrimaryKey(typeof(T), primaryKey);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTableByPrimaryKey<T>(object primaryKey, ColumnExpression[] columnExpressions) where T : System.Data.DataTable
        {
            return (T)GetDataTableByPrimaryKey(typeof(T), primaryKey, columnExpressions);
        }

        /// <summary>
        /// Delete data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByPrimaryKey<T>(object primaryKey)
        {
            return DeleteByPrimaryKey(typeof(T), primaryKey);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Delete<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return Delete(typeof(T), conditionExpression);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateByPrimaryKey<T>(object primaryKey, object[] values)
        {
            return UpdateByPrimaryKey(typeof(T), primaryKey, values);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateByPrimaryKey<T>(object primaryKey, ColumnExpression[] columnExpressions, object[] values)
        {
            return UpdateByPrimaryKey(typeof(T), primaryKey, columnExpressions, values);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateByPrimaryKey<T>(object primaryKey, Dictionary<string, object> values)
        {
            return UpdateByPrimaryKey(typeof(T), primaryKey, values);
        }

        /// <summary>
        /// Update the data according the condition.
        /// </summary>
        /// <remarks>
        /// Pay attention to the parameter name in the addtion condtion.
        /// </remarks>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, object[] values)
        {
            return Update(typeof(T), conditionExpression, values);
        }

        /// <summary>
        /// Update the data according the condition.
        /// </summary>
        /// <remarks>
        /// Pay attention to the parameter name in the addtion condtion.
        /// </remarks>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, ColumnExpression[] columnExpressions, object[] values)
        {
            return Update(typeof(T), conditionExpression, columnExpressions, values);
        }

        /// <summary>
        /// Update the data according the condition.
        /// </summary>
        /// <remarks>
        /// Pay attention to the parameter name in the addtion condtion.
        /// </remarks>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, Dictionary<string, object> values)
        {
            return Update(typeof(T), conditionExpression, values);
        }

        /// <summary>
        /// Check the data by primary key.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>If exists then return true, otherwise return false.</returns>
        public virtual bool ExistsByPrimaryKey<T>(object primaryKey)
        {
            return ExistsByPrimaryKey(typeof(T), primaryKey);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill<T>(System.Data.DataTable dataTable, RaisingStudio.Data.Expressions.ColumnExpression[] columnExpressions)
        {
            return Fill(typeof(T), dataTable, columnExpressions);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill<T>(System.Data.DataTable dataTable, object[] primaryKeys, ColumnExpression[] columnExpressions)
        {
            return Fill(typeof(T), dataTable, primaryKeys, columnExpressions);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTable<T>(ColumnExpression[] columnExpressions) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnExpressions);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTable<T>(object[] primaryKeys, ColumnExpression[] columnExpressions) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), primaryKeys, columnExpressions);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions)
        {
            return Update(typeof(T), dataTable, columnExpressions);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions)
        {
            return Update(typeof(T), dataRows, columnExpressions);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRow">Datarow.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataRow dataRow, ColumnExpression[] columnExpressions)
        {
            return Update(typeof(T), dataRow, columnExpressions);
        }

        /// <summary>
        /// Delete data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="originalValues">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Delete<T>(ColumnExpression[] columnExpressions, object[] originalValues)
        {
            return Delete(typeof(T), columnExpressions, originalValues);
        }

        /// <summary>
        /// Insert data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Insert<T>(ColumnExpression[] columnExpressions, object[] values)
        {
            return Insert(typeof(T), columnExpressions, values);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(ColumnExpression[] columnExpressions, object[] values)
        {
            return Update(typeof(T), columnExpressions, values);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(object[] primaryKeys, ColumnExpression[] columnExpressions, object[] values)
        {
            return Update(typeof(T), primaryKeys, columnExpressions, values);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="originalValues">The original values.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(ColumnExpression[] columnExpressions, object[] originalValues, object[] values)
        {
            return Update(typeof(T), columnExpressions, originalValues, values);
        }

        #region Normal Functions
        /// <summary>
        /// Gets the data row count according the condition.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The count of data rows.</returns>
        public virtual int GetDataCount<T>(ConditionExpression conditionExpression)
        {
            return GetDataCount(typeof(T), conditionExpression);
        }

        /// <summary>
        /// Gets the sum of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the sum of data.</returns>
        public virtual object GetSumData<T>(ColumnExpression columnExpression)
        {
            return GetSumData(typeof(T), columnExpression);
        }

        /// <summary>
        /// Gets the sum of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the sum of data.</returns>
        public virtual object GetSumData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetSumData(typeof(T), columnExpression, conditionExpression);
        }

        /// <summary>
        /// Gets the avg of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the avg of data.</returns>
        public virtual object GetAvgData<T>(ColumnExpression columnExpression)
        {
            return GetAvgData(typeof(T), columnExpression);
        }

        /// <summary>
        /// Gets the avg of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the avg of data.</returns>
        public virtual object GetAvgData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetAvgData(typeof(T), columnExpression, conditionExpression);
        }

        /// <summary>
        /// Gets the max of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the max of data.</returns>
        public virtual object GetMaxData<T>(ColumnExpression columnExpression)
        {
            return GetMaxData(typeof(T), columnExpression);
        }

        /// <summary>
        /// Get the max of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the max of data.</returns>
        public virtual object GetMaxData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetMaxData(typeof(T), columnExpression, conditionExpression);
        }

        /// <summary>
        /// Gets the min of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the min of data.</returns>
        public virtual object GetMinData<T>(ColumnExpression columnExpression)
        {
            return GetMinData(typeof(T), columnExpression);
        }

        /// <summary>
        /// Get the min of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the min of data.</returns>
        public virtual object GetMinData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetMinData(typeof(T), columnExpression, conditionExpression);
        }
        #endregion

        #region 并发冲突及Update 行为
        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, bool checkConcurrency)
        {
            return Update(typeof(T), dataTable, columnExpressions, checkConcurrency);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions, bool checkConcurrency)
        {
            return Update(typeof(T), dataRows, columnExpressions, checkConcurrency);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRow">Datarow.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataRow dataRow, ColumnExpression[] columnExpressions, bool checkConcurrency)
        {
            return Update(typeof(T), dataRow, columnExpressions, checkConcurrency);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, UpdateBehavior updateBehavior)
        {
            return Update(typeof(T), dataTable, columnExpressions, updateBehavior);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions, UpdateBehavior updateBehavior)
        {
            return Update(typeof(T), dataRows, columnExpressions, updateBehavior);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return Update(typeof(T), dataTable, columnExpressions, checkConcurrency, updateBehavior);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return Update(typeof(T), dataRows, columnExpressions, checkConcurrency, updateBehavior);
        }
        #endregion

        #region Paging Operation 
        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, int startRecord, int maxRecords)
        {
            return Fill(typeof(T), dataTable, columnExpressions, startRecord, maxRecords);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill<T>(System.Data.DataTable dataTable, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return Fill(typeof(T), dataTable, conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return Fill(typeof(T), dataTable, columnExpressions, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTable<T>(ColumnExpression[] columnExpressions, int startRecord, int maxRecords) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnExpressions, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTable<T>(ConditionExpression conditionExpression, int startRecord, int maxRecords) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTable<T>(ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnExpressions, conditionExpression, startRecord, maxRecords);
        }
        #endregion

        #region View Mode
        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Datatable.</returns>
        public virtual T GetViewData<T>(ConditionExpression conditionExpression) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), conditionExpression);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Datatable.</returns>
        public virtual T GetViewData<T>(ColumnExpression[] columnExpressions, ConditionExpression conditionExpression) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), columnExpressions, conditionExpression);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView<T>(System.Data.DataTable dataTable, ConditionExpression conditionExpression)
        {
            return FillView(typeof(T), dataTable, conditionExpression);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression)
        {
            return FillView(typeof(T), dataTable, columnExpressions, conditionExpression);
        }

        #region Normal Functions
        /// <summary>
        /// Gets the data row count according the condition.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The count of data rows.</returns>
        public virtual int GetViewDataCount<T>(ConditionExpression conditionExpression)
        {
            return GetViewDataCount(typeof(T), conditionExpression);
        }

        /// <summary>
        /// Gets the sum of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the sum of data.</returns>
        public virtual object GetViewSumData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetViewSumData(typeof(T), columnExpression, conditionExpression);
        }

        /// <summary>
        /// Gets the avg of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the avg of data.</returns>
        public virtual object GetViewAvgData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetViewAvgData(typeof(T), columnExpression, conditionExpression);
        }

        /// <summary>
        /// Get the max of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the max of data.</returns>
        public virtual object GetViewMaxData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetViewMaxData(typeof(T), columnExpression, conditionExpression);
        }

        /// <summary>
        /// Get the min of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the min of data.</returns>
        public virtual object GetViewMinData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetViewMinData(typeof(T), columnExpression, conditionExpression);
        }
        #endregion

        #region Paging Operation 
        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual T GetViewData<T>(ConditionExpression conditionExpression, int startRecord, int maxRecords) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual T GetViewData<T>(ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), columnExpressions, conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView<T>(System.Data.DataTable dataTable, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return FillView(typeof(T), dataTable, conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return FillView(typeof(T), dataTable, columnExpressions, conditionExpression, startRecord, maxRecords);
        }
        #endregion
        #endregion
        #endregion
        #region Transaction
        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill<T>(System.Data.DataTable dataTable, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return Fill(typeof(T), dataTable, conditionExpression, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return Fill(typeof(T), dataTable, columnExpressions, conditionExpression, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillByPrimaryKey<T>(System.Data.DataTable dataTable, object primaryKey, string transactionID)
        {
            return FillByPrimaryKey(typeof(T), dataTable, primaryKey, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillByPrimaryKey<T>(System.Data.DataTable dataTable, object primaryKey, ColumnExpression[] columnExpressions, string transactionID)
        {
            return FillByPrimaryKey(typeof(T), dataTable, primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTable<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTable<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnExpressions, conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTableByPrimaryKey<T>(object primaryKey, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTableByPrimaryKey(typeof(T), primaryKey, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTableByPrimaryKey<T>(object primaryKey, ColumnExpression[] columnExpressions, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTableByPrimaryKey(typeof(T), primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// Delete data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByPrimaryKey<T>(object primaryKey, string transactionID)
        {
            return DeleteByPrimaryKey(typeof(T), primaryKey, transactionID);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Delete<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return Delete(typeof(T), conditionExpression, transactionID);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="values">values.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateByPrimaryKey<T>(object primaryKey, object[] values, string transactionID)
        {
            return UpdateByPrimaryKey(typeof(T), primaryKey, values, transactionID);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateByPrimaryKey<T>(object primaryKey, ColumnExpression[] columnExpressions, object[] values, string transactionID)
        {
            return UpdateByPrimaryKey(typeof(T), primaryKey, columnExpressions, values, transactionID);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="values">values.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateByPrimaryKey<T>(object primaryKey, Dictionary<string, object> values, string transactionID)
        {
            return UpdateByPrimaryKey(typeof(T), primaryKey, values, transactionID);
        }

        /// <summary>
        /// Update the data according the condition.
        /// </summary>
        /// <remarks>
        /// Pay attention to the parameter name in the addtion condtion.
        /// </remarks>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="values">values.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, object[] values, string transactionID)
        {
            return Update(typeof(T), conditionExpression, values, transactionID);
        }

        /// <summary>
        /// Update the data according the condition.
        /// </summary>
        /// <remarks>
        /// Pay attention to the parameter name in the addtion condtion.
        /// </remarks>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, ColumnExpression[] columnExpressions, object[] values, string transactionID)
        {
            return Update(typeof(T), conditionExpression, columnExpressions, values, transactionID);
        }

        /// <summary>
        /// Update the data according the condition.
        /// </summary>
        /// <remarks>
        /// Pay attention to the parameter name in the addtion condtion.
        /// </remarks>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="values">values.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, Dictionary<string, object> values, string transactionID)
        {
            return Update(typeof(T), conditionExpression, values, transactionID);
        }

        /// <summary>
        /// Check the data by primary key.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>If exists then return true, otherwise return false.</returns>
        public virtual bool ExistsByPrimaryKey<T>(object primaryKey, string transactionID)
        {
            return ExistsByPrimaryKey(typeof(T), primaryKey, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill<T>(System.Data.DataTable dataTable, RaisingStudio.Data.Expressions.ColumnExpression[] columnExpressions, string transactionID)
        {
            return Fill(typeof(T), dataTable, columnExpressions, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill<T>(System.Data.DataTable dataTable, object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID)
        {
            return Fill(typeof(T), dataTable, primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTable<T>(ColumnExpression[] columnExpressions, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTable<T>(object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, string transactionID)
        {
            return Update(typeof(T), dataTable, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions, string transactionID)
        {
            return Update(typeof(T), dataRows, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRow">Datarow.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataRow dataRow, ColumnExpression[] columnExpressions, string transactionID)
        {
            return Update(typeof(T), dataRow, columnExpressions, transactionID);
        }

        /// <summary>
        /// Delete data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="originalValues">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Delete<T>(ColumnExpression[] columnExpressions, object[] originalValues, string transactionID)
        {
            return Delete(typeof(T), columnExpressions, originalValues, transactionID);
        }

        /// <summary>
        /// Insert data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Insert<T>(ColumnExpression[] columnExpressions, object[] values, string transactionID)
        {
            return Insert(typeof(T), columnExpressions, values, transactionID);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(ColumnExpression[] columnExpressions, object[] values, string transactionID)
        {
            return Update(typeof(T), columnExpressions, values, transactionID);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(object[] primaryKeys, ColumnExpression[] columnExpressions, object[] values, string transactionID)
        {
            return Update(typeof(T), primaryKeys, columnExpressions, values, transactionID);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="originalValues">The original values.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(ColumnExpression[] columnExpressions, object[] originalValues, object[] values, string transactionID)
        {
            return Update(typeof(T), columnExpressions, originalValues, values, transactionID);
        }

        #region Normal Functions
        /// <summary>
        /// Gets the data row count according the condition.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The count of data rows.</returns>
        public virtual int GetDataCount<T>(ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataCount(typeof(T), conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the sum of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the sum of data.</returns>
        public virtual object GetSumData<T>(ColumnExpression columnExpression, string transactionID)
        {
            return GetSumData(typeof(T), columnExpression, transactionID);
        }

        /// <summary>
        /// Gets the sum of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the sum of data.</returns>
        public virtual object GetSumData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetSumData(typeof(T), columnExpression, conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the avg of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the avg of data.</returns>
        public virtual object GetAvgData<T>(ColumnExpression columnExpression, string transactionID)
        {
            return GetAvgData(typeof(T), columnExpression, transactionID);
        }

        /// <summary>
        /// Gets the avg of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the avg of data.</returns>
        public virtual object GetAvgData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetAvgData(typeof(T), columnExpression, conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the max of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the max of data.</returns>
        public virtual object GetMaxData<T>(ColumnExpression columnExpression, string transactionID)
        {
            return GetMaxData(typeof(T), columnExpression, transactionID);
        }

        /// <summary>
        /// Get the max of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the max of data.</returns>
        public virtual object GetMaxData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetMaxData(typeof(T), columnExpression, conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the min of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the min of data.</returns>
        public virtual object GetMinData<T>(ColumnExpression columnExpression, string transactionID)
        {
            return GetMinData(typeof(T), columnExpression, transactionID);
        }

        /// <summary>
        /// Get the min of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the min of data.</returns>
        public virtual object GetMinData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetMinData(typeof(T), columnExpression, conditionExpression, transactionID);
        }
        #endregion

        #region 并发冲突及Update 行为
        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, bool checkConcurrency, string transactionID)
        {
            return Update(typeof(T), dataTable, columnExpressions, checkConcurrency, transactionID);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions, bool checkConcurrency, string transactionID)
        {
            return Update(typeof(T), dataRows, columnExpressions, checkConcurrency, transactionID);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRow">Datarow.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataRow dataRow, ColumnExpression[] columnExpressions, bool checkConcurrency, string transactionID)
        {
            return Update(typeof(T), dataRow, columnExpressions, checkConcurrency, transactionID);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(typeof(T), dataTable, columnExpressions, updateBehavior, transactionID);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(typeof(T), dataRows, columnExpressions, updateBehavior, transactionID);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(typeof(T), dataTable, columnExpressions, checkConcurrency, updateBehavior, transactionID);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(typeof(T), dataRows, columnExpressions, checkConcurrency, updateBehavior, transactionID);
        }
        #endregion

        #region Paging Operation 
        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, int startRecord, int maxRecords, string transactionID)
        {
            return Fill(typeof(T), dataTable, columnExpressions, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill<T>(System.Data.DataTable dataTable, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return Fill(typeof(T), dataTable, conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return Fill(typeof(T), dataTable, columnExpressions, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTable<T>(ColumnExpression[] columnExpressions, int startRecord, int maxRecords, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnExpressions, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTable<T>(ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual T GetDataTable<T>(ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetDataTable(typeof(T), columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }
        #endregion

        #region View Mode
        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Datatable.</returns>
        public virtual T GetViewData<T>(ConditionExpression conditionExpression, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Datatable.</returns>
        public virtual T GetViewData<T>(ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), columnExpressions, conditionExpression, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView<T>(System.Data.DataTable dataTable, ConditionExpression conditionExpression, string transactionID)
        {
            return FillView(typeof(T), dataTable, conditionExpression, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, string transactionID)
        {
            return FillView(typeof(T), dataTable, columnExpressions, conditionExpression, transactionID);
        }

        #region Normal Functions
        /// <summary>
        /// Gets the data row count according the condition.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The count of data rows.</returns>
        public virtual int GetViewDataCount<T>(ConditionExpression conditionExpression, string transactionID)
        {
            return GetViewDataCount(typeof(T), conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the sum of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the sum of data.</returns>
        public virtual object GetViewSumData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetViewSumData(typeof(T), columnExpression, conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the avg of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the avg of data.</returns>
        public virtual object GetViewAvgData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetViewAvgData(typeof(T), columnExpression, conditionExpression, transactionID);
        }

        /// <summary>
        /// Get the max of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the max of data.</returns>
        public virtual object GetViewMaxData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetViewMaxData(typeof(T), columnExpression, conditionExpression, transactionID);
        }

        /// <summary>
        /// Get the min of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the min of data.</returns>
        public virtual object GetViewMinData<T>(ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetViewMinData(typeof(T), columnExpression, conditionExpression, transactionID);
        }
        #endregion

        #region Paging Operation 
        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual T GetViewData<T>(ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual T GetViewData<T>(ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID) where T : System.Data.DataTable
        {
            return (T)GetViewData(typeof(T), columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView<T>(System.Data.DataTable dataTable, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return FillView(typeof(T), dataTable, conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView<T>(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return FillView(typeof(T), dataTable, columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }
        #endregion
        #endregion
        #endregion
        #endregion
        #region DataObject Functions
        #region Common Methods
        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObjectByPrimaryKey<T>(object dataObject, object primaryKey)
        {
            return FillDataObjectByPrimaryKey(typeof(T), dataObject, primaryKey);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObjectByPrimaryKey<T>(object dataObject, object primaryKey, ColumnExpression[] columnExpressions)
        {
            return FillDataObjectByPrimaryKey(typeof(T), dataObject, primaryKey, columnExpressions);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>Data object.</returns>
        public virtual T GetDataObjectByPrimaryKey<T>(object primaryKey)
        {
            return (T)GetDataObjectByPrimaryKey(typeof(T), primaryKey);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Data object.</returns>
        public virtual T GetDataObjectByPrimaryKey<T>(object primaryKey, ColumnExpression[] columnExpressions)
        {
            return (T)GetDataObjectByPrimaryKey(typeof(T), primaryKey, columnExpressions);
        }

        /// <summary>
        /// Delete Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteDataObjectByPrimaryKey<T>(object primaryKey)
        {
            return DeleteDataObjectByPrimaryKey(typeof(T), primaryKey);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObjectByPrimaryKey<T>(object primaryKey, object dataObject)
        {
            return UpdateDataObjectByPrimaryKey(typeof(T), primaryKey, dataObject);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObjectByPrimaryKey<T>(object primaryKey, object dataObject, ColumnExpression[] columnExpressions)
        {
            return UpdateDataObjectByPrimaryKey(typeof(T), primaryKey, dataObject, columnExpressions);
        }

        /// <summary>
        /// Check data object by primary key.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>If exists then return true, otherwise return false.</returns>
        public virtual bool ExistsDataObjectByPrimaryKey<T>(object primaryKey)
        {
            return ExistsDataObjectByPrimaryKey(typeof(T), primaryKey);
        }

        #region Epxression 
        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Data object.</returns>
        public virtual T GetDataObjectByCondition<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return (T)GetDataObjectByCondition(typeof(T), conditionExpression);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Data object.</returns>
        public virtual T GetDataObjectByCondition<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return (T)GetDataObjectByCondition(typeof(T), columnExpressions, conditionExpression);
        }

        #region Batch Operation 
        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataObjectList(typeof(T), conditionExpression);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataObjectList(typeof(T), columnExpressions, conditionExpression);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataObjectList(typeof(T), conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataObjectList(typeof(T), columnExpressions, conditionExpression, startRecord, maxRecords);
        }
        #endregion

        #region 迭代器
        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataObjectEnumerator(typeof(T), conditionExpression);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataObjectEnumerator(typeof(T), columnExpressions, conditionExpression);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataObjectEnumerator(typeof(T), conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataObjectEnumerator(typeof(T), columnExpressions, conditionExpression, startRecord, maxRecords);
        }
        #endregion
        #endregion
        #endregion

        #region column name Epxression 
        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObject<T>(object dataObject, object[] primaryKeys, ColumnExpression[] columnExpressions)
        {
            return FillDataObject(typeof(T), dataObject, primaryKeys, columnExpressions);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">has primary key value Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObject<T>(object dataObject, ColumnExpression[] columnExpressions)
        {
            return FillDataObject(typeof(T), dataObject, columnExpressions);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Data object.</returns>
        public virtual T GetDataObject<T>(object[] primaryKeys, ColumnExpression[] columnExpressions)
        {
            return (T)GetDataObject(typeof(T), primaryKeys, columnExpressions);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="dataObject">has primary key value Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Data object.</returns>
        public virtual T GetDataObject<T>(object dataObject, ColumnExpression[] columnExpressions)
        {
            return (T)GetDataObject(typeof(T), dataObject, columnExpressions);
        }

        /// <summary>
        /// Insert Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int InsertDataObject<T>(object dataObject, ColumnExpression[] columnExpressions)
        {
            return InsertDataObject(typeof(T), dataObject, columnExpressions);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObject<T>(object dataObject, ColumnExpression[] columnExpressions)
        {
            return UpdateDataObject(typeof(T), dataObject, columnExpressions);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObject<T>(object[] primaryKeys, object dataObject, ColumnExpression[] columnExpressions)
        {
            return UpdateDataObject(typeof(T), primaryKeys, dataObject, columnExpressions);
        }

        /// <summary>
        /// Save Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int SaveDataObject<T>(object dataObject, ColumnExpression[] columnExpressions)
        {
            return SaveDataObject(typeof(T), dataObject, columnExpressions);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList<T>(ColumnExpression[] columnExpressions)
        {
            return GetDataObjectList(typeof(T), columnExpressions);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList<T>(ColumnExpression[] columnExpressions, int startRecord, int maxRecords)
        {
            return GetDataObjectList(typeof(T), columnExpressions, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator<T>(ColumnExpression[] columnExpressions)
        {
            return GetDataObjectEnumerator(typeof(T), columnExpressions);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator<T>(ColumnExpression[] columnExpressions, int startRecord, int maxRecords)
        {
            return GetDataObjectEnumerator(typeof(T), columnExpressions, startRecord, maxRecords);
        }
        #endregion
        #endregion
        #endregion
        #region Transaction
        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObjectByPrimaryKey<T>(object dataObject, object primaryKey, string transactionID)
        {
            return FillDataObjectByPrimaryKey(typeof(T), dataObject, primaryKey, transactionID);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObjectByPrimaryKey<T>(object dataObject, object primaryKey, ColumnExpression[] columnExpressions, string transactionID)
        {
            return FillDataObjectByPrimaryKey(typeof(T), dataObject, primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data object.</returns>
        public virtual T GetDataObjectByPrimaryKey<T>(object primaryKey, string transactionID)
        {
            return (T)GetDataObjectByPrimaryKey(typeof(T), primaryKey, transactionID);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data object.</returns>
        public virtual T GetDataObjectByPrimaryKey<T>(object primaryKey, ColumnExpression[] columnExpressions, string transactionID)
        {
            return (T)GetDataObjectByPrimaryKey(typeof(T), primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// Delete Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteDataObjectByPrimaryKey<T>(object primaryKey, string transactionID)
        {
            return DeleteDataObjectByPrimaryKey(typeof(T), primaryKey, transactionID);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObjectByPrimaryKey<T>(object primaryKey, object dataObject, string transactionID)
        {
            return UpdateDataObjectByPrimaryKey(typeof(T), primaryKey, dataObject, transactionID);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObjectByPrimaryKey<T>(object primaryKey, object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return UpdateDataObjectByPrimaryKey(typeof(T), primaryKey, dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Check data object by primary key.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>If exists then return true, otherwise return false.</returns>
        public virtual bool ExistsDataObjectByPrimaryKey<T>(object primaryKey, string transactionID)
        {
            return ExistsDataObjectByPrimaryKey(typeof(T), primaryKey, transactionID);
        }

        #region Epxression 
        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data object.</returns>
        public virtual T GetDataObjectByCondition<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return (T)GetDataObjectByCondition(typeof(T), conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data object.</returns>
        public virtual T GetDataObjectByCondition<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return (T)GetDataObjectByCondition(typeof(T), columnExpressions, conditionExpression, transactionID);
        }

        #region Batch Operation 
        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataObjectList(typeof(T), conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataObjectList(typeof(T), columnExpressions, conditionExpression, transactionID);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectList(typeof(T), conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectList(typeof(T), columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }
        #endregion

        #region 迭代器
        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataObjectEnumerator(typeof(T), conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataObjectEnumerator(typeof(T), columnExpressions, conditionExpression, transactionID);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectEnumerator(typeof(T), conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectEnumerator(typeof(T), columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }
        #endregion
        #endregion
        #endregion

        #region column name Epxression 
        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObject<T>(object dataObject, object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID)
        {
            return FillDataObject(typeof(T), dataObject, primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">has primary key value Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObject<T>(object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return FillDataObject(typeof(T), dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data object.</returns>
        public virtual T GetDataObject<T>(object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID)
        {
            return (T)GetDataObject(typeof(T), primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="dataObject">has primary key value Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data object.</returns>
        public virtual T GetDataObject<T>(object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return (T)GetDataObject(typeof(T), dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Insert Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int InsertDataObject<T>(object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return InsertDataObject(typeof(T), dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObject<T>(object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return UpdateDataObject(typeof(T), dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObject<T>(object[] primaryKeys, object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return UpdateDataObject(typeof(T), primaryKeys, dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Save Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int SaveDataObject<T>(object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return SaveDataObject(typeof(T), dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList<T>(ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectList(typeof(T), columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList<T>(ColumnExpression[] columnExpressions, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectList(typeof(T), columnExpressions, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator<T>(ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectEnumerator(typeof(T), columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator<T>(ColumnExpression[] columnExpressions, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectEnumerator(typeof(T), columnExpressions, startRecord, maxRecords, transactionID);
        }
        #endregion
        #endregion
        #endregion
        #endregion
        #region DataItem Functions
        #region Common Methods
        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItemByPrimaryKey<T>(RaisingStudio.Data.DataItem dataItem, object primaryKey)
        {
            return FillDataItemByPrimaryKey(typeof(T), dataItem, primaryKey);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItemByPrimaryKey<T>(RaisingStudio.Data.DataItem dataItem, object primaryKey, ColumnExpression[] columnExpressions)
        {
            return FillDataItemByPrimaryKey(typeof(T), dataItem, primaryKey, columnExpressions);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItemByPrimaryKey<T>(object primaryKey) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItemByPrimaryKey(typeof(T), primaryKey);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItemByPrimaryKey<T>(object primaryKey, ColumnExpression[] columnExpressions) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItemByPrimaryKey(typeof(T), primaryKey, columnExpressions);
        }

        /// <summary>
        /// Delete Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteDataItemByPrimaryKey<T>(object primaryKey)
        {
            return DeleteDataItemByPrimaryKey(typeof(T), primaryKey);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItemByPrimaryKey<T>(object primaryKey, RaisingStudio.Data.DataItem dataItem)
        {
            return UpdateDataItemByPrimaryKey(typeof(T), primaryKey, dataItem);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItemByPrimaryKey<T>(object primaryKey, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return UpdateDataItemByPrimaryKey(typeof(T), primaryKey, dataItem, columnExpressions);
        }

        /// <summary>
        /// Check the data item exists or not.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>If exists then return true, otherwise return false.</returns>
        public virtual bool ExistsDataItemByPrimaryKey<T>(object primaryKey)
        {
            return ExistsDataItemByPrimaryKey(typeof(T), primaryKey);
        }

        #region Epxression 
        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Data item.</returns>
        public virtual T GetDataItemByCondition<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItemByCondition(typeof(T), conditionExpression);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Data item.</returns>
        public virtual T GetDataItemByCondition<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItemByCondition(typeof(T), columnExpressions, conditionExpression);
        }

        #region Batch Operation 
        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataItemList(typeof(T), conditionExpression);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataItemList(typeof(T), columnExpressions, conditionExpression);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataItemList(typeof(T), conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataItemList(typeof(T), columnExpressions, conditionExpression, startRecord, maxRecords);
        }
        #endregion

        #region 迭代器
        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataItemEnumerator(typeof(T), conditionExpression);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataItemEnumerator(typeof(T), columnExpressions, conditionExpression);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataItemEnumerator(typeof(T), conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataItemEnumerator(typeof(T), columnExpressions, conditionExpression, startRecord, maxRecords);
        }
        #endregion
        #endregion
        #endregion

        #region column name Epxression 
        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItem<T>(RaisingStudio.Data.DataItem dataItem, object[] primaryKeys, ColumnExpression[] columnExpressions)
        {
            return FillDataItem(typeof(T), dataItem, primaryKeys, columnExpressions);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item that contains primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItem<T>(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return FillDataItem(typeof(T), dataItem, columnExpressions);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Data item.</returns>
        public virtual T GetDataItem<T>(object[] primaryKeys, ColumnExpression[] columnExpressions) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItem(typeof(T), primaryKeys, columnExpressions);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="dataItem">Data item that contains primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Data item.</returns>
        public virtual T GetDataItem<T>(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItem(typeof(T), dataItem, columnExpressions);
        }

        /// <summary>
        /// Insert Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int InsertDataItem<T>(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return InsertDataItem(typeof(T), dataItem, columnExpressions);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItem<T>(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return UpdateDataItem(typeof(T), dataItem, columnExpressions);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItem<T>(object[] primaryKeys, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return UpdateDataItem(typeof(T), primaryKeys, dataItem, columnExpressions);
        }

        /// <summary>
        /// Save Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int SaveDataItem<T>(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return SaveDataItem(typeof(T), dataItem, columnExpressions);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList<T>(ColumnExpression[] columnExpressions)
        {
            return GetDataItemList(typeof(T), columnExpressions);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList<T>(ColumnExpression[] columnExpressions, int startRecord, int maxRecords)
        {
            return GetDataItemList(typeof(T), columnExpressions, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator<T>(ColumnExpression[] columnExpressions)
        {
            return GetDataItemEnumerator(typeof(T), columnExpressions);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator<T>(ColumnExpression[] columnExpressions, int startRecord, int maxRecords)
        {
            return GetDataItemEnumerator(typeof(T), columnExpressions, startRecord, maxRecords);
        }
        #endregion
        #endregion
        #endregion
        #region Transaction
        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItemByPrimaryKey<T>(RaisingStudio.Data.DataItem dataItem, object primaryKey, string transactionID)
        {
            return FillDataItemByPrimaryKey(typeof(T), dataItem, primaryKey, transactionID);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItemByPrimaryKey<T>(RaisingStudio.Data.DataItem dataItem, object primaryKey, ColumnExpression[] columnExpressions, string transactionID)
        {
            return FillDataItemByPrimaryKey(typeof(T), dataItem, primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItemByPrimaryKey<T>(object primaryKey, string transactionID) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItemByPrimaryKey(typeof(T), primaryKey, transactionID);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItemByPrimaryKey<T>(object primaryKey, ColumnExpression[] columnExpressions, string transactionID) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItemByPrimaryKey(typeof(T), primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// Delete Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteDataItemByPrimaryKey<T>(object primaryKey, string transactionID)
        {
            return DeleteDataItemByPrimaryKey(typeof(T), primaryKey, transactionID);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItemByPrimaryKey<T>(object primaryKey, RaisingStudio.Data.DataItem dataItem, string transactionID)
        {
            return UpdateDataItemByPrimaryKey(typeof(T), primaryKey, dataItem, transactionID);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItemByPrimaryKey<T>(object primaryKey, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return UpdateDataItemByPrimaryKey(typeof(T), primaryKey, dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Check the data item exists or not.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>If exists then return true, otherwise return false.</returns>
        public virtual bool ExistsDataItemByPrimaryKey<T>(object primaryKey, string transactionID)
        {
            return ExistsDataItemByPrimaryKey(typeof(T), primaryKey, transactionID);
        }

        #region Epxression 
        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data item.</returns>
        public virtual T GetDataItemByCondition<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItemByCondition(typeof(T), conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data item.</returns>
        public virtual T GetDataItemByCondition<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItemByCondition(typeof(T), columnExpressions, conditionExpression, transactionID);
        }

        #region Batch Operation 
        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataItemList(typeof(T), conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataItemList(typeof(T), columnExpressions, conditionExpression, transactionID);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemList(typeof(T), conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemList(typeof(T), columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }
        #endregion

        #region 迭代器
        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataItemEnumerator(typeof(T), conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataItemEnumerator(typeof(T), columnExpressions, conditionExpression, transactionID);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator<T>(RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemEnumerator(typeof(T), conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator<T>(ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemEnumerator(typeof(T), columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }
        #endregion
        #endregion
        #endregion

        #region column name Epxression 
        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItem<T>(RaisingStudio.Data.DataItem dataItem, object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID)
        {
            return FillDataItem(typeof(T), dataItem, primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item that contains primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItem<T>(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return FillDataItem(typeof(T), dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data item.</returns>
        public virtual T GetDataItem<T>(object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItem(typeof(T), primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="dataItem">Data item that contains primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data item.</returns>
        public virtual T GetDataItem<T>(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID) where T : RaisingStudio.Data.DataItem
        {
            return (T)GetDataItem(typeof(T), dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Insert Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int InsertDataItem<T>(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return InsertDataItem(typeof(T), dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItem<T>(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return UpdateDataItem(typeof(T), dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItem<T>(object[] primaryKeys, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return UpdateDataItem(typeof(T), primaryKeys, dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Save Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int SaveDataItem<T>(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return SaveDataItem(typeof(T), dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList<T>(ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemList(typeof(T), columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList<T>(ColumnExpression[] columnExpressions, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemList(typeof(T), columnExpressions, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator<T>(ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemEnumerator(typeof(T), columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator<T>(ColumnExpression[] columnExpressions, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemEnumerator(typeof(T), columnExpressions, startRecord, maxRecords, transactionID);
        }
        #endregion
        #endregion
        #endregion
        #endregion
        #region DataSet Functions
        #region Common Methods
        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <returns>dataset.</returns>
        public virtual T GetDataSet<T>(TableExpression[] tableExpressions) where T : System.Data.DataSet
        {
            return (T)GetDataSet(typeof(T), tableExpressions);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill<T>(System.Data.DataSet dataSet, TableExpression[] tableExpressions)
        {
            return Fill(typeof(T), dataSet, tableExpressions);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataSet dataSet, TableExpression[] tableExpressions)
        {
            return Update(typeof(T), dataSet, tableExpressions);
        }


        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>dataset.</returns>
        public virtual T GetDataSet<T>(Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary) where T : System.Data.DataSet
        {
            return (T)GetDataSet(typeof(T), columnExpressionsDictionary);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill<T>(System.Data.DataSet dataSet, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary)
        {
            return Fill(typeof(T), dataSet, columnExpressionsDictionary);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataSet dataSet, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary)
        {
            return Update(typeof(T), dataSet, columnExpressionsDictionary);
        }


        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>dataset.</returns>
        public virtual T GetDataSet<T>(TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary) where T : System.Data.DataSet
        {
            return (T)GetDataSet(typeof(T), tableExpressions, columnExpressionsDictionary);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataSet dataSet, TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary)
        {
            return Update(typeof(T), dataSet, tableExpressions, columnExpressionsDictionary);
        }

        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <returns>dataset.</returns>
        public virtual T GetDataByRelation<T>(RaisingStudio.Data.Expressions.TableExpression tableExpression, object[] primaryKeys, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode) where T : System.Data.DataSet
        {
            return (T)GetDataByRelation(typeof(T), tableExpression, primaryKeys, columnExpressionsDictionary, viewMode);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelation<T>(System.Data.DataSet dataSet, TableExpression tableExpression, object[] primaryKeys, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode)
        {
            return FillByRelation(typeof(T), dataSet, tableExpression, primaryKeys, columnExpressionsDictionary, viewMode);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelationByPrimaryKey<T>(System.Data.DataSet dataSet, TableExpression tableExpression, object primaryKey, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode)
        {
            return FillByRelationByPrimaryKey(typeof(T), dataSet, tableExpression, primaryKey, columnExpressionsDictionary, viewMode);
        }

        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="viewMode">view mode.</param>
        /// <returns>dataset.</returns>
        public virtual T GetDataByRelation<T>(TableExpression tableExpression, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, ConditionExpression conditionExpression, bool viewMode) where T : System.Data.DataSet
        {
            return (T)GetDataByRelation(typeof(T), tableExpression, columnExpressionsDictionary, conditionExpression, viewMode);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="viewMode">view mode.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelation<T>(System.Data.DataSet dataSet, TableExpression tableExpression, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, ConditionExpression conditionExpression, bool viewMode)
        {
            return FillByRelation(typeof(T), dataSet, tableExpression, columnExpressionsDictionary, conditionExpression, viewMode);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByRelation<T>(TableExpression tableExpression, object[] primaryKeys)
        {
            return DeleteByRelation(typeof(T), tableExpression, primaryKeys);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByRelationByPrimaryKey<T>(TableExpression tableExpression, object primaryKey)
        {
            return DeleteByRelationByPrimaryKey(typeof(T), tableExpression, primaryKey);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByRelation<T>(TableExpression tableExpression, ConditionExpression conditionExpression)
        {
            return DeleteByRelation(typeof(T), tableExpression, conditionExpression);
        }
        #endregion
        #region Transaction
        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>dataset.</returns>
        public virtual T GetDataSet<T>(TableExpression[] tableExpressions, string transactionID) where T : System.Data.DataSet
        {
            return (T)GetDataSet(typeof(T), tableExpressions, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill<T>(System.Data.DataSet dataSet, TableExpression[] tableExpressions, string transactionID)
        {
            return Fill(typeof(T), dataSet, tableExpressions, transactionID);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataSet dataSet, TableExpression[] tableExpressions, string transactionID)
        {
            return Update(typeof(T), dataSet, tableExpressions, transactionID);
        }


        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>dataset.</returns>
        public virtual T GetDataSet<T>(Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID) where T : System.Data.DataSet
        {
            return (T)GetDataSet(typeof(T), columnExpressionsDictionary, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill<T>(System.Data.DataSet dataSet, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID)
        {
            return Fill(typeof(T), dataSet, columnExpressionsDictionary, transactionID);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataSet dataSet, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID)
        {
            return Update(typeof(T), dataSet, columnExpressionsDictionary, transactionID);
        }


        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>dataset.</returns>
        public virtual T GetDataSet<T>(TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID) where T : System.Data.DataSet
        {
            return (T)GetDataSet(typeof(T), tableExpressions, columnExpressionsDictionary, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill<T>(System.Data.DataSet dataSet, TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID)
        {
            return Fill(typeof(T), dataSet, tableExpressions, columnExpressionsDictionary, transactionID);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update<T>(System.Data.DataSet dataSet, TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID)
        {
            return Update(typeof(T), dataSet, tableExpressions, columnExpressionsDictionary, transactionID);
        }


        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>dataset.</returns>
        public virtual T GetDataByRelation<T>(RaisingStudio.Data.Expressions.TableExpression tableExpression, object[] primaryKeys, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode, string transactionID) where T : System.Data.DataSet
        {
            return (T)GetDataByRelation(typeof(T), tableExpression, primaryKeys, columnExpressionsDictionary, viewMode, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelation<T>(System.Data.DataSet dataSet, TableExpression tableExpression, object[] primaryKeys, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode, string transactionID)
        {
            return FillByRelation(typeof(T), dataSet, tableExpression, primaryKeys, columnExpressionsDictionary, viewMode, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelationByPrimaryKey<T>(System.Data.DataSet dataSet, TableExpression tableExpression, object primaryKey, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode, string transactionID)
        {
            return FillByRelationByPrimaryKey(typeof(T), dataSet, tableExpression, primaryKey, columnExpressionsDictionary, viewMode, transactionID);
        }

        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="viewMode">view mode.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>dataset.</returns>
        public virtual T GetDataByRelation<T>(TableExpression tableExpression, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, ConditionExpression conditionExpression, bool viewMode, string transactionID) where T : System.Data.DataSet
        {
            return (T)GetDataByRelation(typeof(T), tableExpression, columnExpressionsDictionary, conditionExpression, viewMode, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="viewMode">view mode.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelation<T>(System.Data.DataSet dataSet, TableExpression tableExpression, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, ConditionExpression conditionExpression, bool viewMode, string transactionID)
        {
            return FillByRelation(typeof(T), dataSet, tableExpression, columnExpressionsDictionary, conditionExpression, viewMode, transactionID);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByRelation<T>(TableExpression tableExpression, object[] primaryKeys, string transactionID)
        {
            return DeleteByRelation(typeof(T), tableExpression, primaryKeys, transactionID);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByRelationByPrimaryKey<T>(TableExpression tableExpression, object primaryKey, string transactionID)
        {
            return DeleteByRelationByPrimaryKey(typeof(T), tableExpression, primaryKey, transactionID);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByRelation<T>(TableExpression tableExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return DeleteByRelation(typeof(T), tableExpression, conditionExpression, transactionID);
        }
        #endregion
        #endregion
        #endregion
    }
}
